GfSentence.java

// This file is part of AceWiki.
// Copyright 2013, AceWiki developers.
//
// AceWiki is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License as published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// AceWiki is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
// even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License along with AceWiki. If
// not, see http://www.gnu.org/licenses/.

package ch.uzh.ifi.attempto.acewiki.gf;

import static ch.uzh.ifi.attempto.ape.OutputType.DRSPP;
import static ch.uzh.ifi.attempto.ape.OutputType.OWLFSSPP;
import static ch.uzh.ifi.attempto.ape.OutputType.PARAPHRASE1;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang.StringEscapeUtils;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLOntologyCreationException;
import org.semanticweb.owlapi.model.SWRLRule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;

import ch.uzh.ifi.attempto.acewiki.core.Declaration;
import ch.uzh.ifi.attempto.acewiki.core.MultilingualSentence;
import ch.uzh.ifi.attempto.acewiki.core.OntologyElement;
import ch.uzh.ifi.attempto.acewiki.core.PrettyTextElement;
import ch.uzh.ifi.attempto.acewiki.core.SentenceDetail;
import ch.uzh.ifi.attempto.acewiki.owl.AceWikiOWLReasoner2;
import ch.uzh.ifi.attempto.acewiki.owl.OWLSentence;
import ch.uzh.ifi.attempto.ape.ACEParserResult;
import ch.uzh.ifi.attempto.ape.ACEText;
import ch.uzh.ifi.attempto.base.DefaultTextOperator;
import ch.uzh.ifi.attempto.base.MultiTextContainer;
import ch.uzh.ifi.attempto.base.TextContainer;
import ch.uzh.ifi.attempto.base.TextElement;
import ch.uzh.ifi.attempto.base.TextOperator;
import ch.uzh.ifi.attempto.echocomp.LocaleResources;
import ch.uzh.ifi.attempto.gfservice.GfServiceException;

/**
 * This class represents a sentence for the GF AceWiki engine.
 * A "sentence" is a tree set that can be linearized into multiple
 * languages.
 *
 * @author Kaarel Kaljurand
 */
public abstract class GfSentence extends MultilingualSentence implements OWLSentence {

	private final Logger mLogger = LoggerFactory.getLogger(GfSentence.class);

	protected final GfGrammar mGfGrammar;
	protected final GfWikiEntry mGfWikiEntry;

	// Use the original input in the text container
	// TODO: this is a hack
	boolean mUseOriginal = true;

	// Maps a language identifier to the set of linearizations (text containers) in this language
	final Map<String, MultiTextContainer> textContainers = new HashMap<>();

	// Maps a tree to the set of linearizations for each language.
	// ie. Map<Tree, Map<Language, Set<Linearization>>>
	// Lazy initialized as tree linearizations are requested, but done for all languages at once - performance reasons.
	private final Map<String, Map<String, Set<String>>> treeLinearizations = new HashMap<>();


	// These fields are evaluated lazily
	private Boolean isReasonable;
	private Boolean isOWL;
	private Boolean isOWLSWRL;
	private Set<OWLAxiom> owlAxioms;

	/**
	 * Creates a declaration from an existing wiki entry (from the storage).
	 * Each wiki entry is tagged with the language in which the entry was created.
	 * Each wiki entry also contains the original text that was used to create the
	 * trees. In case the trees can not be linearized (because the grammar has changed)
	 * then we try to parse the original text instead (which might also fail).
	 */
	public GfSentence(GfGrammar grammar, GfWikiEntry entry) {
		mGfGrammar = grammar;

		boolean isParseable = (entry.getLanguage() != null && entry.getText() != null);

		if (isParseable && hasBadTrees(entry.getLanguage(), entry.getTrees())) {
			mGfWikiEntry = createGfWikiEntry(grammar, entry.getLanguage(), entry.getText());
		} else {
			mGfWikiEntry = entry;
		}
	}


	/**
	 * Creates a declaration object from the given text.
	 * The text will be parsed to get the trees.
	 */
	public GfSentence(GfGrammar grammar, String language, String text) {
		mGfGrammar = grammar;
		mGfWikiEntry = createGfWikiEntry(grammar, language, text);
	}

	public static GfSentence createGfSentence(GfGrammar grammar, GfWikiEntry entry) {
		if (entry.getText().contains("?")) {
			return new GfQuestion(grammar, entry);
		}
		return new GfDeclaration(grammar, entry);
	}

	/**
	 * Maps this declaration to its visual representation in the given language.
	 * The declaration is a set of trees.
	 * Each tree can in principle have multiple linearizations (variants), but we currently
	 * consider only the first (canonical) variant.
	 * We have to handle the following:
	 *   - the linearization fails (e.g. tree is malformed)
	 *   - a tree has an empty set of linearizations
	 *   - a linearization is an empty string
	 *   - a lineariation repeats
	 *   - the user wants to see what he/she originally entered not a rewrite into the canonical variant
	 */
	public MultiTextContainer getTextContainer(String language) {
		MultiTextContainer mtc = textContainers.get(language);
		if (mtc == null) {
			List<TextContainer> tmp = new ArrayList<>();
			TextOperator to = getTextOperator(language);

			// If the text is requested in the original language (i.e. in which the entry was first created)
			// then we return the original text. The benefit is that we do not need to make a call
			// to the linearizer. Also, there is no danger that the original text would be replaced by a variant
			// (e.g. "does not -> doesn't") which would be confusing.
			if (mUseOriginal && language.equals(mGfWikiEntry.getLanguage()) && mGfWikiEntry.getText() != null) {
				tmp = ImmutableList.of(makeTextContainer(to, mGfWikiEntry.getText()));
			} else {
				Set<String> seen = Sets.newHashSet();
				for (String tree : mGfWikiEntry.getTrees().getTrees()) {
					Set<String> lins = getLins(tree, language);
					if (lins == null) {
						mLogger.info("getTextContainer: null {}: {}", language, tree);
						// TODO do it properly
						tmp.add(new TextContainer(new TextElement("-NULL-" + tree)));
					} else if (lins.isEmpty()) {
						mLogger.info("getTextContainer: empty {}: {}", language, tree);
						// TODO do it properly
						tmp.add(new TextContainer(new TextElement("-EMPTY-" + tree)));
					} else {
						String lin = lins.iterator().next();
						if (lin.isEmpty() || seen.contains(lin)) {
							// Don't show an empty lin and the same lin twice
						} else {
							seen.add(lin);
							tmp.add(makeTextContainer(to, lin));
						}
					}
				}
			}
			if (tmp.isEmpty()) {
				tmp.add(new TextContainer(new TextElement("-NO_LINEARIZATION_FOUND-")));
			}
			mtc = new MultiTextContainer(tmp);
			textContainers.put(language, mtc);
		}
		return mtc;
	}

	/**
	 * TODO: this is temporary. Also note that it does not have effect on the
	 * original input as this is always taken from mGfWikiEntry.getText()
	 */
	public void clearLinearizations() {
		textContainers.clear();
		treeLinearizations.clear();
		mUseOriginal = false;
	}


	TextContainer makeTextContainer(TextOperator to, String str) {
		TextContainer tc = new TextContainer(to);
		for (String s : to.splitIntoTokens(str)) {
			tc.addElement(new PrettyTextElement(s));
		}
		return tc;
	}


	/**
	 * TODO
	 */
	public boolean contains(OntologyElement e) {
		return false;
	}


	/**
	 * Returns the details of this tree set:
	 * 
	 *   - abstract trees;
	 *   - translations;
	 *   - abstract tree diagram;
	 *   - parse tree diagram;
	 *   - word alignment diagram;
	 *   - ...
	 * 
	 * The output highlights the given language.
	 *
	 * TODO: everything should be hyperlinked.
	 */
	public List<SentenceDetail> getDetails(String lang, int index) {
		List<SentenceDetail> l = new ArrayList<SentenceDetail>();

		if (mGfGrammar.isAceCompatible()) {
			l.addAll(getSemantics(index));
		}

		l.addAll(formatTree(mGfGrammar, lang, index));

		return l;
	}


	public int getNumberOfRepresentations() {
		return mGfWikiEntry.getTrees().size();
	}


	public List<String> getParseTrees() {
		return mGfWikiEntry.getTrees().getTrees();
	}


	public GfWikiEntry getGfWikiEntry() {
		return mGfWikiEntry;
	}


	public String serialize() {
		return GfGrammar.serialize(mGfWikiEntry);
	}


	public void update() {
		Set<Set<OWLAxiom>> setOfSetOfAxiom = null;
		String uri = getOntology().getURI();
		try {
			setOfSetOfAxiom = GfOwlConverter.convert(mGfGrammar, uri, mGfWikiEntry);
		} catch (OWLOntologyCreationException e1) {
			// TODO
		}

		if (setOfSetOfAxiom == null || setOfSetOfAxiom.isEmpty()) {
			isOWLSWRL = isOWL = isReasonable = false;
			owlAxioms = new HashSet<OWLAxiom>();
		} else {
			isOWLSWRL = isOWL = isReasonable = true;
			owlAxioms = GfOwlConverter.disambiguate(setOfSetOfAxiom);

			// TODO: currently not reasoning with SWRL rules, this should
			// be controlled by the profile instead
			for (OWLAxiom ax : owlAxioms) {
				if (ax instanceof SWRLRule) {
					isOWL = isReasonable = false;
					mLogger.info("Axiom is SWRL rule: {}", ax);
					break;
				}
			}
		}

		// TODO: check also questions somehow, e.g. EL probably does not allow inverse properties in questions
		if (isReasonable && this instanceof Declaration) {
			AceWikiOWLReasoner2 reasoner = (AceWikiOWLReasoner2) getOntology().getReasoner().getWrappedReasoner();
			isReasonable = GfOwlConverter.isReasonable(reasoner, owlAxioms);
		}

		if (!isReasonable && isIntegrated()) {
			super.setIntegrated(false);
		}
	}


	// TODO: this method does not make sense for GF-wiki entries
	// because they can be ambiguous.
	public String getPrettyOWL() {
		return null;
	}


	public boolean isReasonable() {
		if (isReasonable == null) {
			update();
		}
		return isReasonable;
	}

	public boolean isOWL() {
		if (isOWL == null) {
			update();
		}
		return isOWL;
	}

	public boolean isOWLSWRL() {
		if (isOWLSWRL == null) {
			update();
		}
		return isOWLSWRL;
	}

	public Set<OWLAxiom> getOWLAxioms() {
		if (owlAxioms == null) {
			update();
		}
		return owlAxioms;
	}

	/**
	 * Returns the grammar object.
	 * 
	 * @return The grammar object.
	 */
	protected GfGrammar getGfGrammar() {
		return mGfGrammar;
	}


	// Return some of the APE analysis of the tree at the given index.
	// The APE analysis is obtained by first linearizing the tree in "Ape".
	// This only works if the wiki is ACE-based.
	//
	// TODO: experimental
	private List<SentenceDetail> getSemantics(int index) {
		String tree = mGfWikiEntry.getTrees().getTrees().get(index);
		List<SentenceDetail> l = new ArrayList<SentenceDetail>();

		if (tree == null) {
			l.add(new SentenceDetail("ERROR", "Statement is not well-formed"));
			return l;
		}

		try {
			ACEText acetext = GfWikiUtils.getACEText(mGfGrammar, tree);
			ACEParserResult pr = GfWikiUtils.parse(acetext, getOntology().getURI(), PARAPHRASE1, OWLFSSPP, DRSPP);

			l.add(new SentenceDetail("ACE", "<pre>" + StringEscapeUtils.escapeHtml(acetext.getText()) + "</pre>"));
			l.add(new SentenceDetail("ACE (paraphrase)", "<pre>" + StringEscapeUtils.escapeHtml(pr.get(PARAPHRASE1)) + "</pre>"));
			l.add(new SentenceDetail("OWL", "<pre>" + StringEscapeUtils.escapeHtml(pr.get(OWLFSSPP)) + "</pre>"));
			l.add(new SentenceDetail("DRS", "<pre>" + StringEscapeUtils.escapeHtml(pr.get(DRSPP)) + "</pre>"));
			l.add(new SentenceDetail("Lexicon", "<pre>" + StringEscapeUtils.escapeHtml(Joiner.on('\n').join(acetext.getLexicon().getEntries())) + "</pre>"));
			l.add(new SentenceDetail("Messages",
					"<pre>" + StringEscapeUtils.escapeHtml(Joiner.on('\n').join(pr.getMessageContainer().getMessages())) + "</pre>"));
		} catch (Exception e) {
			l.add(new SentenceDetail("ERROR", e.getMessage()));
		}

		return l;
	}


	private String getAbstrtreeAsHtml(String tree) {
		try {
			return getImg(getGfGrammar().abstrtree(tree));
		} catch (GfServiceException e) {
			return getError(e);
		}
	}


	private String getParsetreeAsHtml(String tree, String language) {
		try {
			return getImg(getGfGrammar().parsetree(tree, language));
		} catch (GfServiceException e) {
			return getError(e);
		}
	}


	private String getImg(String dataUri) {
		return "<a href=\"" + dataUri + "\"><img src=\"" + dataUri + "\" style=\"max-height:500px\"/></a>";
	}


	private static String getError(Exception e) {
		return "<p style=\"color: red\">" + e.getMessage() + "</p>";
	}


	private List<SentenceDetail> formatTree(GfGrammar grammar, String lang, int index) {
		String tree = mGfWikiEntry.getTrees().getTrees().get(index);
		List<SentenceDetail> l = new ArrayList<SentenceDetail>();
		l.add(new SentenceDetail("acewiki_details_syntree", getParsetreeAsHtml(tree, lang)));
		l.add(new SentenceDetail(
				LocaleResources.getString("acewiki_details_internal") + " (ASCII)",
				"<p><code>" + tree + "</code></p>"
				));
		l.add(new SentenceDetail("acewiki_details_internal", getAbstrtreeAsHtml(tree)));
		return l;
	}


	Set<String> getLins(String tree, String language) {
		// Linearization of a single tree to all possible languages.
		Map<String, Set<String>> tl = treeLinearizations.get(tree);

		if (tl == null) {
			try {
				tl = getGfGrammar().linearize(tree);
				treeLinearizations.put(tree, tl);
			} catch (GfServiceException e) {
				// TODO find out what happened, i.e.
				// why was the tree not supported by the grammar.
				mLogger.warn("tree not supported by the grammar - {}: {}", language, tree);
				return null;
			}
		}

		return tl.get(language);
	}

	private boolean hasBadTrees(String language, TreeList treeList) {
		for (String tree : treeList.getTrees()) {
			Set<String> lins = getLins(tree, language);
			if (lins == null || lins.isEmpty()) {
				return true;
			}
		}
		return false;
	}


	private static GfWikiEntry createGfWikiEntry(GfGrammar grammar, String language, String text) {
		try {
			Set<String> trees = grammar.parse(text, language);
			if (trees == null) {
				throw new RuntimeException("No such language: " + language);
			}
			if (trees.isEmpty()) {
				// TODO this should be done properly; see GfTextOperator
				// If parsing fails: first char to lower case
				text = DefaultTextOperator.firstCharToLowerCase(text);
				trees = grammar.parse(text, language);
			}
			return new GfWikiEntry(language, text, new TreeList(trees));
		} catch (GfServiceException e) {
			throw new RuntimeException(e.getMessage());
		}
	}
}